home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / CodeWarrior Lite / Metrowerks C⁄C++ Lite / Headers / ANSI Headers / dynarray < prev    next >
Encoding:
Text File  |  1994-12-09  |  5.0 KB  |  186 lines  |  [TEXT/MMCC]
  1. // dynarray standard header
  2. #ifndef _DYNARRAY_
  3. #define _DYNARRAY_
  4. #include <exception>
  5.  
  6. #if __MWERKS__
  7. #pragma options align=mac68k
  8. #endif
  9.  
  10.   // template class dynarray
  11. template<class _T> class dynarray {
  12. public:
  13.  dynarray()
  14.   {_Tidy(); }
  15.  dynarray(size_t _N, capacity _C)
  16.   {_Tidy(), _Res = _N;
  17.   if (_C == default_size)
  18.    _Grow(_N); }
  19.  dynarray(const dynarray<_T>& _X)
  20.   {_Tidy(), _Grow(_X.length());
  21.   for (size_t _I = 0; _I < _Len; ++_I)
  22.    _Ptr[_I] = (_T)_X[_I]; }
  23.  dynarray(const _T& _X, size_t _N = 1)
  24.   {_Tidy(), _Grow(_N, &_X); }
  25.  dynarray(const _T *_S, size_t _N)
  26.   {if (_S == 0)
  27.    _Xinv();
  28.   _Tidy(), assign(_S, _N); }
  29.  ~dynarray()
  30.   {_Tidy(1); }
  31.  dynarray<_T>& operator=(const dynarray<_T>& _R)
  32.   {return (this == &_R ? *this
  33.    : assign(_R.base(), _R.length())); }
  34.  dynarray<_T>& operator+=(const dynarray<_T>& _R)
  35.   {return (append(_R.base(), _R.length())); }
  36.  dynarray<_T>& operator+=(const _T& _R)
  37.   {return (append(_R)); }
  38.  dynarray<_T>& append(const _T& _X, size_t _N = 1)
  39.   {return (append(&_X, _N, 0)); }
  40.  dynarray<_T>& append(const _T *_S, size_t _N = 1,
  41.   size_t _D = 1)
  42.   {if (NPOS - _Len <= _N)
  43.    _Xlen();
  44.   size_t _I = _Len;
  45.   for (_Grow(_N += _I); _I < _N; ++_I, _S += _D)
  46.    _Ptr[_I] = (_T)*_S;
  47.   return (*this); }
  48.  dynarray<_T>& assign(const _T& _X, size_t _N = 1)
  49.   {return (assign(&_X, _N, 0)); }
  50.  dynarray<_T>& assign(const _T *_S, size_t _N = 1,
  51.   size_t _D = 1)
  52.   {_Grow(_N, 0, 1);
  53.   for (size_t _I = 0; _I < _N; ++_I, _S += _D)
  54.    _Ptr[_I] = (_T)*_S;
  55.   return (*this); }
  56.  dynarray<_T>& insert(size_t _P, const dynarray<_T>& _X)
  57.   {return (insert(_P, _X.base(), _X.length())); }
  58.  dynarray<_T>& insert(size_t _P, const _T& _X, size_t _N = 1)
  59.   {return (insert(_P, &_X, _N, 0)); }
  60.  dynarray<_T>& insert(size_t _P, const _T *_S, size_t _N = 1,
  61.   size_t _D = 1)
  62.   {if (_Len < _P)
  63.    _Xran();
  64.   if (NPOS - _Len <= _N)
  65.    _Xlen();
  66.   if (0 < _N)
  67.    {size_t _I = _Len - _P;
  68.    for (_Grow(_N + _Len); 0 < _I; )
  69.     --_I, _Ptr[_P + _N + _I] = _Ptr[_P + _I];
  70.    for (_I = 0; _I < _N; ++_I, _S += _D)
  71.     _Ptr[_P + _I] = (_T)*_S; }
  72.   return (*this); }
  73.  dynarray<_T>& remove(size_t _P = 0, size_t _N = NPOS)
  74.   {if (_Len < _P)
  75.    _Xran();
  76.   if (_Len - _P < _N)
  77.    _N = _Len - _P;
  78.   if (0 < _N)
  79.    {size_t _M = _Len - _P - _N;
  80.    for (size_t _I = 0; _I < _M; ++_I)
  81.     _Ptr[_P + _I] = _Ptr[_P + _I + _N];
  82.    _Grow(_Len - _N); }
  83.   return (*this); }
  84.  dynarray<_T>& sub_array(dynarray<_T>& _X, size_t _P,
  85.   size_t _N = NPOS)
  86.   {if (_Len < _P)
  87.    _Xran();
  88.   if (_Len - _P < _N)
  89.    _N = _Len - _P;
  90.   return (this == &_X ? (remove(_P + _N), remove(0, _P))
  91.    : _X.assign(&_Ptr[_P], _N)); }
  92.  void swap(dynarray<_T>& _X)
  93.   {_T *_Tp = _Ptr; _Ptr = _X._Ptr, _X._Ptr = _Tp;
  94.   size_t _Tl = _Len; _Len = _X._Len, _X._Len = _Tl;
  95.   size_t _Tr = _Res; _Res = _X._Res, _X._Res = _Tr; }
  96.  const _T& get_at(size_t _I) const
  97.   {if (_Len <= _I)
  98.    _Xran();
  99.   return (_Ptr[_I]); } 
  100.  void put_at(size_t _I, const _T& _X)
  101.   {if (_Len <= _I)
  102.    _Xran();
  103.   _Ptr[_I] = (_T)_X; } 
  104.  _T& operator[](size_t _I)
  105.   {return (_Ptr[_I]); } 
  106.  const _T& operator[](size_t _I) const
  107.   {return (_Ptr[_I]); } 
  108.  _T *base()
  109.   {return (_Len != 0 ? _Ptr : 0); }
  110.  const _T *base() const
  111.   {return (_Len != 0 ? _Ptr : 0); }
  112.  size_t length() const
  113.   {return (_Len); }
  114.  void resize(size_t _N)
  115.   {_Grow(_N, 0, 1); }
  116.  void resize(size_t _N, const _T& _X)
  117.   {_Grow(_N, &_X, 1); }
  118.  size_t reserve() const
  119.   {return (_Res); }
  120.  void reserve(size_t _R)
  121.   {if (_Ptr == 0)
  122.    _Res = _R; }
  123. private:
  124.  void _Grow(size_t _N, const _T *_S = 0, _Bool _Trim = 0)
  125.   {size_t _Os = _Ptr == 0 ? 0 : _Res;
  126.   if (_N == 0)
  127.    {if (_Trim)
  128.     _Tidy(1); }
  129.   else if (_N == _Os || _N < _Os && !_Trim)
  130.    { }
  131.   else if (_N == NPOS)
  132.    _Xlen();
  133.   else
  134.    {size_t _I, _M = _Ptr == 0 && _N < _Res ? _Res : _N;
  135.    _T *_Np = new _T[_M];
  136.    if (_Np == 0)
  137.     _Nomemory();
  138.    _Res = _M, _M = _N < _Len ? _N : _Len;
  139.    for (_I = 0; _I < _M; ++_I)
  140.     _Np[_I] = _Ptr[_I];
  141.    if (_S != 0)
  142.     for (; _I < _Res; ++_I)
  143.      _Np[_I] = (_T)*_S;
  144.    _Tidy(1), _Ptr = _Np; }
  145.   _Len = _N; }
  146.  void _Tidy(_Bool _Constructed = 0)
  147.   {if (_Constructed && _Ptr != 0)
  148.    delete[] _Ptr;
  149.   _Len = 0, _Ptr = 0, _Res = 0; }
  150.  void _Xinv() const
  151.   {invalidargument("invalid dynarray argument").raise(); }
  152.  void _Xlen() const
  153.   {lengtherror("dynarray too long").raise(); }
  154.  void _Xran() const
  155.   {outofrange("invalid dynarray position").raise(); }
  156.   _T *_Ptr;
  157.  size_t _Len, _Res;
  158.  };
  159.   // template operators
  160. template<class _T> dynarray<_T>
  161.  operator+(const dynarray<_T>& _L, const dynarray<_T>& _R)
  162.  {return (dynarray<_T>(_L) += _R); }
  163. template<class _T> dynarray<_T>
  164.  operator+(const dynarray<_T>& _L, const _T& _R)
  165.  {return (dynarray<_T>(_L) += _R); }
  166. template<class _T> dynarray<_T>
  167.  operator+(const _T& _L, const dynarray<_T>& _R)
  168.  {return (dynarray<_T>(_L) += _R); }
  169.  
  170. #if __MWERKS__
  171. #pragma options align=reset
  172. #endif
  173.  
  174. #endif
  175.  
  176. /*
  177.  * Copyright (c) 1994 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  178.  * Consult your license regarding permissions and restrictions.
  179.  */
  180.  
  181. /* Change log:
  182.  *94Oct03 Version received from PlumHall
  183.  *94Oct07 Inserted MW changes.
  184.  *94Nov01mm Added explicit pointer casts of form (_T) in lines 22, 47, 55, 71, 103 and 143
  185.  */
  186.